import java.io.IOException;
import java.util.ArrayList;
import java.util.Random;



public class CacaPalavras extends Console {
	/** **************************************************************************************
	 * CONSTANTES
	 *  **************************************************************************************/
	static final int TOTAL_PALAVRAS = 5;
	static final int MAXSIZE = 10;
	static final int JOGAR = 1, SAIR = 2;
	static final int HORIZONTAL_DE = 0, HORIZONTAL_ED = 1, VERTICAL_CB = 2, VERTICAL_BC = 3;
	
	final static String[] palavras = {"BRASIL", "CHINA", "CHILE", "ITALIA", "FRANCA"};
	
	/** **************************************************************************************
	 * IMPRIMIR O TABULEIRO (MATRIZ)
	 *  **************************************************************************************/
	public static void imprime(char[][] matriz){
		System.out.print("  ");
		for (int i = 0; i < MAXSIZE; i++){
			System.out.printf("%2d", i);
		}
		System.out.println();
		
		for (int i = 0; i < MAXSIZE; i++){
			System.out.printf("%2d", i);
			for (int j = 0; j < MAXSIZE; j++)
				System.out.printf("%2c", matriz[i][j]);
			System.out.println();
		}
	}
	
	public static void main(String[] args) throws IOException  {
		char[][] matriz = new char[MAXSIZE][MAXSIZE];
		// INICIALIZA A MATRIZ
		for (int i = 0; i < MAXSIZE; i++){
			for (int j = 0; j < MAXSIZE; j++){
				matriz[i][j] = '-';
			}
		}
		
		boolean fim = false;
		int opt = 0;
	
		/** **************************************************************************************
		 * Menu principal
		 *  **************************************************************************************/
		while (opt != 1 && opt != 2) {
			opt = Console.leInt("1. Para Jogar\n2. Para Sair");
			
		}		
		/** **************************************************************************************
		 * Loop principal
		 *  **************************************************************************************/
		int ds = 0; // Direcao sentido;
		int l,c; // Linha l coluna c;
		
		Random r = new Random();
		ArrayList<String> palavrasUtilizadas = new ArrayList<String>();
		
		switch(opt){
			case JOGAR:
				ArrayList<String> palavrasEncontradas = new ArrayList<String>();
				boolean encaixa;
				String palavra = "";
				for (int i = 0; i < TOTAL_PALAVRAS; i++) {
					do {
						palavra = palavras[r.nextInt(palavras.length)];
					} while (palavrasUtilizadas.contains(palavra));
					
					
					encaixa = false;
					while (!encaixa) {
						ds = r.nextInt(4);
						l = r.nextInt(MAXSIZE);
						c = r.nextInt(MAXSIZE);
						
						switch(ds){
							case HORIZONTAL_ED: // HORIZONTAL ESQUERDA PARA DIREITA
								if (MAXSIZE - c >=  palavra.length()){
									for (int k = c, m = 0; m < palavra.length(); k++, m++){
										if (matriz[l][k] != '-'){ 
											encaixa = false;
											break;
										} else {
											encaixa = true;
										}
									}
									if (encaixa) {
										for (int k = c, m = 0; m < palavra.length(); k++, m++){
											matriz[l][k] = palavra.charAt(m);
										}
									}
									
								}
								break;
							
							case HORIZONTAL_DE: // HORIZONTAL DIREITA PARA ESQUERDA
								if (c >= palavra.length()){
									for (int k = c, m = 0; m < palavra.length(); k--, m++){
										if (matriz[l][k] != '-'){ 
											encaixa = false;
											break;
										} else {
											encaixa = true;
										}
									}
									if (encaixa) {
										for (int k = c, m = 0; m < palavra.length(); k--, m++){
											matriz[l][k] = palavra.charAt(m); 
										}
									}
								}
								break;
							
							case VERTICAL_CB: // VERTICAL CIMA PARA BAIXO
								if (MAXSIZE - l >=  palavra.length()){
									for (int k = l, m = 0; m < palavra.length(); k++, m++){
										if (matriz[k][c] != '-'){ 
											encaixa = false;
											break;
										} else {
											encaixa = true;
										}
									}
									if (encaixa) {
										for (int k = l, m = 0; m < palavra.length(); k++, m++){
											matriz[k][c] = palavra.charAt(m);
										}
									}
								}
								break;
								
							case VERTICAL_BC: // VERTICAL DE BAIXO PARA CIMA 
								if (l >= palavra.length()){
									for (int k = l, m = 0; m < palavra.length(); k--, m++){
										if (matriz[k][c] != '-'){ 
											encaixa = false;
											break;
										} else {
											encaixa = true;
										}
									}
									if (encaixa) {
										for (int k = l, m = 0; m < palavra.length(); k--, m++){
											matriz[k][c] = palavra.charAt(m);
										}
									}
								}
								break;
						}
					}
					palavrasUtilizadas.add(palavra);
				}
				
				for (int i = 0; i < MAXSIZE; i++){
					for (int j = 0; j < MAXSIZE; j++){
						if (matriz[i][j] == '-'){
							matriz[i][j] = (char)(r.nextInt(26)+65);
						}
					}
				}
				int li = 0,ci = 0,lf = 0,cf = 0;
				boolean numeroValido = false;
				String str = new String();
				
				while (!fim){
					System.out.println("***************************************************");
					System.out.println("Palavras: ");
					for (String p: palavrasUtilizadas){
						if (!palavrasEncontradas.contains(p)){
							System.out.println(p);
						} else {
							System.out.println("<-- " +p + " -->");
						}
					}
					imprime(matriz);
					/** **************************************************************************************
					 * Le linhas e colunas para tentar encontrar uma palavra
					 *  **************************************************************************************/
					numeroValido = false;
					while (!numeroValido){
						li = Console.leInt("Informe a linha inicial");
						if (li >= 0 && li < MAXSIZE) {
							numeroValido = true;
						} else {
							System.out.println("Entrada Invailda. Tente novamente.");
						}
					}
					numeroValido = false;
					while (!numeroValido) {
						ci = Console.leInt("Informe a coluna inicial");
						if (ci >= 0 && ci < MAXSIZE) {
							numeroValido = true;
						} else {
							System.out.println("Entrada Invailda. Tente novamente.");
						}
					}
					numeroValido = false;
					while (!numeroValido) {
						lf = Console.leInt("Infomre a linha final");
						if (lf >= 0 && lf < MAXSIZE) {
							numeroValido = true;
						} else {
							System.out.println("Entrada Invailda. Tente novamente.");
						}
					}
					numeroValido = false;
					while (!numeroValido) {
						cf = Console.leInt("Informe a coluna final");
						if (cf >= 0 && cf < MAXSIZE) {
							numeroValido = true;
						} else {
							System.out.println("Entrada Invailda. Tente novamente.");
						}
					}
					
					
					/** **************************************************************************************
					 * Verifica palavra
					 *****************************************************************************************/
					str = "";
					
					int sinal = 0, i = 0 , j = 0;
					if (li == lf){ //HORIZONTAL
						sinal = (cf - ci)/Math.abs(cf - ci);
						for (i = li, j = ci; j != cf; j = j + sinal){
							str += matriz[i][j];
						}
					} else if (ci == cf) { //VERTICAL
						sinal = (lf -li)/Math.abs(lf -li);
						for (i = li, j = ci; i != lf; i = i + sinal){
							str += matriz[i][j];
						}
					}
					str += matriz[i][j];
					boolean palavraEncontrada = false;
					
					if (palavrasUtilizadas.contains(str)) {
						palavraEncontrada = true;
						palavrasEncontradas.add(str);
					}
					
					if (palavraEncontrada){
						if (li == lf){ // HORIZONTAL
							for (i = li, j = ci; j != cf; j = j + sinal){
								matriz[i][j] = ' ';
							}
						} else if (ci == cf) { // VERTICAL
							for (i = li, j = ci; i != lf; i = i + sinal){
								matriz[i][j] = ' ';
							}
						}
						matriz[i][j] = ' ';
						System.out.println("Palavra encontrada: "+str);
					} else {
						System.out.println("Este intervalo nao representa uma palavra valida.");
					}
					
					if (palavrasEncontradas.size() == TOTAL_PALAVRAS) {
						fim = true;
					}
				}
				
				break;
			case SAIR:
				System.out.println("Saindo do Jogo");
				break;
			default:
				System.out.println("Numero invalido");
				break;
		}
	}
}